/**
 * 用户认证状态管理工具类
 * 处理用户登录状态、令牌管理等
 */

import { authAPI } from './api.js'
import { APP_CONFIG, PAGES, utils } from './config.js'

// 存储键名常量
const STORAGE_KEYS = {
	TOKEN: utils.getStorageKey(APP_CONFIG.TOKEN_KEY),
	USER_INFO: utils.getStorageKey(APP_CONFIG.USER_INFO_KEY),
	LOGIN_TIME: utils.getStorageKey('login_time')
}

/**
 * 用户认证管理类
 */
class AuthManager {
	constructor() {
		this.userInfo = null
		this.token = null
		this.isLoggedIn = false
		this.init()
	}

	/**
	 * 初始化认证状态
	 */
	init() {
		try {
			// 从本地存储恢复用户信息
			const token = uni.getStorageSync(STORAGE_KEYS.TOKEN)
			const userInfo = uni.getStorageSync(STORAGE_KEYS.USER_INFO)
			const loginTime = uni.getStorageSync(STORAGE_KEYS.LOGIN_TIME)

			if (token && userInfo) {
				this.token = token
				this.userInfo = userInfo
				this.isLoggedIn = true

				// 检查登录是否过期
				const now = Date.now()
				const expireDays = APP_CONFIG.LOGIN_EXPIRE_DAYS * 24 * 60 * 60 * 1000
				if (loginTime && (now - loginTime) > expireDays) {
					utils.log('info', '登录已过期，清除本地状态')
					this.clearAuth()
				}
			}
		} catch (error) {
			utils.log('error', '初始化认证状态失败', error)
			this.clearAuth()
		}
	}

	/**
	 * 用户登录（两步登录流程）
	 * @param {Object} loginData 登录数据
	 */
	async login(loginData) {
		try {
			// 第一步：获取登录授权码
			utils.log('info', '开始两步登录流程 - 第一步：获取授权码')
			const authResult = await authAPI.getLoginAuthCode(loginData)
			
			if (authResult.code !== 200) {
				throw new Error(authResult.message || '获取登录授权码失败')
			}
			
			utils.log('info', '获取授权码成功，开始第二步：获取令牌')
			
			// 第二步：使用授权码获取令牌
			const tokenResult = await authAPI.getLoginToken(loginData,authResult.data)
			
			if (tokenResult.code === 200 && tokenResult.data) {
				// 后端返回TokenDTO格式
				const { accessToken, refreshToken, imAccessToken, imSessionToken } = tokenResult.data
				
				// 保存认证信息
				this.token = accessToken
				this.isLoggedIn = true

				// 持久化存储
				uni.setStorageSync(STORAGE_KEYS.TOKEN, accessToken)
				uni.setStorageSync(STORAGE_KEYS.LOGIN_TIME, Date.now())
				
				// 保存刷新令牌
				if (refreshToken) {
					uni.setStorageSync(utils.getStorageKey('refresh_token'), refreshToken)
				}
				
				// 保存IM相关令牌
				if (imAccessToken) {
					uni.setStorageSync(utils.getStorageKey('im_access_token'), imAccessToken)
				}
				if (imSessionToken) {
					uni.setStorageSync(utils.getStorageKey('im_session_token'), imSessionToken)
				}
				
				// 获取用户信息
				try {
					const userInfo = await this.refreshUserInfo()
					this.userInfo = userInfo
				} catch (userInfoError) {
					utils.log('warn', '获取用户信息失败，但登录成功', userInfoError)
				}
				
				utils.log('info', '两步登录成功', { 
					hasAccessToken: !!accessToken,
					hasRefreshToken: !!refreshToken,
					hasImTokens: !!(imAccessToken && imSessionToken)
				})

				return tokenResult
			} else {
				throw new Error(tokenResult.message || '获取登录令牌失败')
			}
		} catch (error) {
			utils.log('error', '两步登录失败', error)
			throw error
		}
	}

	/**
	 * 用户登出
	 */
	async logout() {
		try {
			// 调用后端登出接口
			if (this.token) {
				await authAPI.logout()
			}
		} catch (error) {
			console.error('登出接口调用失败:', error)
		} finally {
			// 无论接口是否成功，都清除本地状态
			this.clearAuth()
		}
	}

	/**
	 * 清除认证信息
	 */
	clearAuth() {
		this.token = null
		this.userInfo = null
		this.isLoggedIn = false

		// 清除本地存储
		uni.removeStorageSync(STORAGE_KEYS.TOKEN)
		uni.removeStorageSync(STORAGE_KEYS.USER_INFO)
		uni.removeStorageSync(STORAGE_KEYS.LOGIN_TIME)
		uni.removeStorageSync(utils.getStorageKey('refresh_token'))
		uni.removeStorageSync(utils.getStorageKey('im_access_token'))
		uni.removeStorageSync(utils.getStorageKey('im_session_token'))
		
		utils.log('info', '认证信息已清除')
	}

	/**
	 * 检查登录状态
	 */
	async checkLoginStatus() {
		if (!this.token) {
			return false
		}

		try {
			const result = await authAPI.checkLoginStatus()
			if (result.code === 200 && result.data === true) {
				return true
			} else {
				// 登录状态无效，清除本地状态
				this.clearAuth()
				return false
			}
		} catch (error) {
			console.error('检查登录状态失败:', error)
			this.clearAuth()
			return false
		}
	}

	/**
	 * 刷新用户信息
	 */
	async refreshUserInfo() {
		if (!this.token) {
			throw new Error('未登录')
		}

		try {
			// 使用验证令牌接口获取用户信息
			const result = await authAPI.verifyToken()
			if (result.code === 200 && result.data) {
				// 后端返回UserInfoDto格式
				const userInfo = result.data
				this.userInfo = userInfo
				uni.setStorageSync(STORAGE_KEYS.USER_INFO, userInfo)
				
				utils.log('debug', '用户信息已更新', { 
					userId: userInfo.id, 
					username: userInfo.username,
					mobile: userInfo.mobile 
				})
				
				return userInfo
			} else {
				throw new Error(result.message || '获取用户信息失败')
			}
		} catch (error) {
			utils.log('error', '刷新用户信息失败', error)
			throw error
		}
	}

	/**
	 * 刷新令牌
	 */
	async refreshToken() {
		const refreshToken = uni.getStorageSync(utils.getStorageKey('refresh_token'))
		if (!refreshToken) {
			throw new Error('未找到刷新令牌')
		}

		try {
			const result = await authAPI.refreshToken()
			if (result.code === 200 && result.data) {
				// 后端返回TokenDTO格式
				const { accessToken, refreshToken: newRefreshToken, imAccessToken, imSessionToken } = result.data
				
				this.token = accessToken
				uni.setStorageSync(STORAGE_KEYS.TOKEN, accessToken)
				
				// 更新刷新令牌
				if (newRefreshToken) {
					uni.setStorageSync(utils.getStorageKey('refresh_token'), newRefreshToken)
				}
				
				// 更新IM相关令牌
				if (imAccessToken) {
					uni.setStorageSync(utils.getStorageKey('im_access_token'), imAccessToken)
				}
				if (imSessionToken) {
					uni.setStorageSync(utils.getStorageKey('im_session_token'), imSessionToken)
				}
				
				utils.log('debug', '令牌刷新成功')
				return accessToken
			} else {
				throw new Error(result.message || '刷新令牌失败')
			}
		} catch (error) {
			utils.log('error', '刷新令牌失败', error)
			// 刷新失败，清除认证状态
			this.clearAuth()
			throw error
		}
	}

	/**
	 * 获取当前用户信息
	 */
	getCurrentUser() {
		return this.userInfo
	}

	/**
	 * 获取当前令牌
	 */
	getToken() {
		return this.token
	}

	/**
	 * 检查是否已登录
	 */
	isAuthenticated() {
		return this.isLoggedIn && this.token && this.userInfo
	}

	/**
	 * 需要登录时的处理
	 * @param {String} redirectUrl 登录后重定向的页面
	 */
	requireLogin(redirectUrl = '') {
		if (!this.isAuthenticated()) {
			// 保存重定向地址
			if (redirectUrl) {
				uni.setStorageSync('redirect_after_login', redirectUrl)
			}
			
			// 跳转到登录页面
			uni.navigateTo({
				url: PAGES.LOGIN
			})
			return false
		}
		return true
	}

	/**
	 * 登录成功后的重定向处理
	 */
	handleLoginSuccess() {
		const redirectUrl = uni.getStorageSync('redirect_after_login')
		uni.removeStorageSync('redirect_after_login')

		if (redirectUrl) {
			// 重定向到指定页面
			if (redirectUrl.startsWith('/pages/')) {
				uni.redirectTo({ 
					url: redirectUrl,
					success: () => {
						// 通知页面刷新用户信息
						uni.$emit('userLoginSuccess')
					}
				})
			} else {
				uni.switchTab({ 
					url: redirectUrl,
					success: () => {
						// 通知页面刷新用户信息
						uni.$emit('userLoginSuccess')
					}
				})
			}
		} else {
			// 默认跳转到首页
			uni.switchTab({ 
				url: PAGES.INDEX,
				success: () => {
					// 通知页面刷新用户信息
					uni.$emit('userLoginSuccess')
				}
			})
		}
	}
}

// 创建全局认证管理实例
const authManager = new AuthManager()

// 导出认证管理器和相关方法
export default authManager

export {
	authManager,
	STORAGE_KEYS
}